package someTestExcemple.huaweiOd.greedyMethod;

//华为OD机试 - 士兵过河II - 贪心思维（Java 2025 A卷 200分）
import java.util.*;
import java.util.Arrays;
import java.util.Scanner;

public class SoldierCrossingRiver {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int T = scanner.nextInt();
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i] = scanner.nextInt();
        }
        scanner.close();

        Arrays.sort(a); // 升序排序，a[0]最快，a[N-1]最慢
        int alive = 0;
        int totalTime = 0;
        int left = 0; // 指向当前最快的士兵
        int right = N - 1; // 指向当前最慢的士兵

        while (left <= right) {
            if (left == right) {
                // 只剩1人，单独过河（条件1）
                int time = a[left];
                if (totalTime + time <= T) {
                    alive++;
                    totalTime += time;
                }
                break;
            } else if (right - left == 1) {
                // 只剩2人，计算两人过河的最优时间（条件2或条件3）
                int time = getTwoPassengersTime(a[left], a[right]);
                if (totalTime + time <= T) {
                    alive += 2;
                    totalTime += time;
                }
                break;
            }

            // 计算两种策略的总用时
            int strategy1 = calculateStrategy1(a, left, right);
            int strategy2 = calculateStrategy2(a, left, right);

            if (totalTime + strategy1 <= T && totalTime + strategy2 <= T) {
                // 选择用时更短的策略
                if (strategy1 < strategy2) {
                    totalTime += strategy1;
                    alive += 2; // 每次策略处理2个最慢的士兵
                    right -= 2; // 最慢和次慢已过河
                } else {
                    totalTime += strategy2;
                    alive += 2;
                    right -= 2;
                }
            } else if (totalTime + strategy1 <= T) {
                totalTime += strategy1;
                alive += 2;
                right -= 2;
            } else if (totalTime + strategy2 <= T) {
                totalTime += strategy2;
                alive += 2;
                right -= 2;
            } else {
                // 无法再运送任何士兵，退出
                break;
            }
        }

        System.out.println(alive + " " + totalTime);
    }

    /**
     * 计算两人过河的最优时间（考虑条件2和条件3）
     */
    private static int getTwoPassengersTime(int a, int b) {
        // 条件2：两人都划，用时max(a,b)
        // 条件3：一人划，用时min(a*10, b*10)
        return Math.min(Math.max(a, b), Math.min(a * 10, b * 10));
    }

    /**
     * 策略一：最快和次快过河 → 最快返回 → 最慢和次慢过河 → 次快返回
     * 总步骤：2人去 + 1人回 + 2人去 + 1人回
     */
    private static int calculateStrategy1(int[] a, int left, int right) {
        int n1 = a[left]; // 最快
        int n2 = a[left + 1]; // 次快
        int nr = a[right]; // 最慢
        int nr1 = a[right - 1]; // 次慢

        // 步骤1：最快和次快过河
        int step1 = getTwoPassengersTime(n1, n2);
        // 步骤2：最快返回（条件1，用时n1）
        int step2 = n1;
        // 步骤3：最慢和次慢过河
        int step3 = getTwoPassengersTime(nr, nr1);
        // 步骤4：次快返回（条件1，用时n2）
        int step4 = n2;

        return step1 + step2 + step3 + step4;
    }

    /**
     * 策略二：最快和最慢过河 → 最快返回 → 最快和次慢过河 → 最快返回
     * 总步骤：2人去 + 1人回 + 2人去 + 1人回
     */
    private static int calculateStrategy2(int[] a, int left, int right) {
        int n1 = a[left]; // 最快
        int nr = a[right]; // 最慢
        int nr1 = a[right - 1]; // 次慢

        // 步骤1：最快和最慢过河
        int step1 = getTwoPassengersTime(n1, nr);
        // 步骤2：最快返回（条件1，用时n1）
        int step2 = n1;
        // 步骤3：最快和次慢过河
        int step3 = getTwoPassengersTime(n1, nr1);
        // 步骤4：最快返回（条件1，用时n1）
        int step4 = n1;

        return step1 + step2 + step3 + step4;
    }
}